home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / mint / utils / lack.zoo / wind.c < prev    next >
C/C++ Source or Header  |  1994-01-02  |  5KB  |  236 lines
  1. #include "lack.h"
  2.  
  3. ki;
  4. extern lap *curapp;
  5. extern lap *lapps[NUM_APPS];
  6. extern int apid;
  7.  
  8. /* trap2.c: */
  9. int _super_aes(unsigned long);
  10.  
  11. #define IN_UPDATE 0x1
  12. #define IN_MCTRL  0x2
  13.  
  14. struct wind
  15. {
  16.     int w_handle, w_visible, w_owner;
  17.     struct wind *w_ap_next, *w_gl_next;
  18. };
  19.  
  20. Wind_create(AESP *call)
  21. {
  22.     int handle, sr;
  23.     struct wind *new;
  24.     struct wind *old=curapp->windows;
  25.     
  26.     handle=call->int_out[0];
  27.     if(handle<0) return 0;
  28.     sr=spl7();
  29.     new=(struct wind *)kmalloc(sizeof(*new));
  30.     spl(sr);
  31.     DEBUG("wind_create: handle %d, structure at %lx", handle, new);
  32.     new->w_handle=handle;
  33.     new->w_visible=FALSE;
  34.     new->w_ap_next=curapp->windows;
  35.     curapp->windows=new;
  36.     return 0;
  37. }
  38.  
  39. Wind_delete(AESP *call)
  40. {
  41.     int handle=call->int_in[0];
  42.     struct wind *w=curapp->windows;
  43.     struct wind _prev;
  44.     struct wind *prev=&_prev;
  45.  
  46.     DEBUG("deleting window %d", handle);
  47.     prev->w_ap_next=w;
  48.     while(w)
  49.         if(w->w_handle != handle)
  50.         {
  51.             prev=w;
  52.             w=w->w_ap_next;
  53.         }
  54.         else break;
  55.     if(!w) ALERT("wind_delete: apid %d does not owm window %d", apid, handle);
  56.     else
  57.     {
  58.         prev->w_ap_next=w->w_ap_next;
  59.         kfree(w);
  60.         curapp->windows=_prev.w_ap_next;
  61.     }
  62.     return 0;
  63. }
  64.  
  65. Wind_open(AESP *call)
  66. {
  67.     struct wind *w=curapp->windows;
  68.     int handle=call->int_in[0];
  69.  
  70.     DEBUG("opening window %d", handle);
  71.     while(w)
  72.         if(w->w_handle != handle)
  73.         w=w->w_ap_next;
  74.         else break;
  75.     if(w) w->w_visible=TRUE;
  76.     else ALERT("wind_open apid %d does not own window handle %d",
  77.            apid, handle);
  78.     return 0;
  79. }
  80.  
  81. Wind_close(AESP *call)
  82. {
  83.     struct wind *w=curapp->windows;
  84.     int handle=call->int_in[0];
  85.  
  86.     DEBUG("closing window %d", handle);
  87.     while(w)
  88.     {
  89.         if(w->w_handle != handle)
  90.         w=w->w_ap_next;
  91.         else break;
  92.     }
  93.     if(w) w->w_visible=FALSE;
  94.     else ALERT("wind_close apid %d does not own window handle %d",
  95.            apid, handle);
  96.     return 0;
  97. }
  98.  
  99. int
  100. Wind_update(AESP *call)
  101. {
  102.     int begend=call->int_in[0];
  103.  
  104.     TRACE("wind_update(%d)", begend);
  105.     switch(begend)
  106.     {
  107.         case END_UPDATE:
  108.             curapp->update &= ~IN_UPDATE;
  109.             break;
  110.         case BEG_UPDATE:
  111.             curapp->update |= IN_UPDATE;
  112.             break;
  113.         case END_MCTRL:
  114.             curapp->update &= ~IN_MCTRL;
  115.             break;
  116.         case BEG_MCTRL:
  117.             curapp->update |= IN_MCTRL;
  118.             break;
  119.         default:
  120.             DEBUG("wind_update: unknown mode");
  121.     }
  122.     return 0;
  123. }
  124.  
  125. int
  126. _wind_cleanup(void)
  127. {
  128.     /* walk down the caller's window list making the aes call wind_delete
  129.      */
  130.     struct wind *old, *w=curapp->windows;
  131.     int handle;
  132.  
  133.     DEBUG("lack: emulating wind_new for apid %d, clearing its windows", apid);
  134.     while(w)
  135.     {
  136.         if(w->w_visible) wind_close(w->w_handle);
  137.         wind_delete(w->w_handle);
  138.         old=w;
  139.         w=w->w_ap_next;
  140.         kfree(old);
  141.     }
  142.     curapp->windows=NULL;
  143. }
  144.  
  145. int
  146. _wind_new(void)
  147. {
  148.     /* delete the callers window + all ackessories windows, leave prgs
  149.      * in ackessory slots alone.
  150.      */
  151.     lap *ap;
  152.     struct wind *w, *old;
  153.     int c;
  154.  
  155.     DEBUG("lack: emulating wind_new, clearing all windows");
  156.     for(c=2; c<NUM_APPS - 1; ap=lapps[c++])
  157.     {
  158.         if(ap)
  159.            if(ap->acc)
  160.               if(!(ap->acc->free || ap->acc->isprg))
  161.               /* neither free nor a program */
  162.               {
  163.                   w=ap->windows;
  164.                   while(w)
  165.                   {
  166.                       if(w->w_visible) wind_close(w->w_handle);
  167.                       wind_delete(w->w_handle);
  168.                       old=w;
  169.                       w=w->w_ap_next;
  170.                       kfree(old);
  171.                   }
  172.                   ap->windows=NULL;
  173.               }
  174.     }
  175.     w=lapps[0]->windows;
  176.     while(w)
  177.     {
  178.         if(w->w_visible) wind_close(w->w_handle);
  179.         wind_delete(w->w_handle);
  180.         old=w;
  181.         w=w->w_ap_next;
  182.         kfree(old);
  183.     }
  184.     lapps[0]->windows=NULL;
  185.     return 1;
  186. }
  187.  
  188. Wind_new(AESP *call)
  189. {
  190.     int (*old__aes__)()=__aes__;
  191.     AESP *old_aes=_aesparams;
  192.     NEW_AESP(a);
  193.  
  194.     _aesparams=&a;
  195.     __aes__=_super_aes;
  196.     if(apid==0) _wind_new();
  197.     else _wind_cleanup();
  198.     if (curapp->update & IN_UPDATE)
  199.     {
  200.         DEBUG("wind_new: ending update");
  201.         wind_update(END_UPDATE);
  202.     }
  203.     if (curapp->update & IN_MCTRL)
  204.     {
  205.         DEBUG("wind_new: ending mctrl");
  206.         wind_update(END_MCTRL);
  207.     }
  208.     __aes__=_super_aes;
  209.     _aesparams=old_aes;
  210.     __aes__=old__aes__;
  211. /*    call->int_out[0]=1; gemlib says this is void */
  212.     return 1;
  213. }
  214.  
  215. void
  216. desk_zap_windows(void)
  217. {
  218.     /* desktop has done wind_new and launched a prg */
  219.     struct wind *die, *next;
  220.     int c;
  221.     
  222.     DEBUG("desktop has cleared all windows");
  223.     for(c=0; c<NUM_APPS; c++)
  224.       if(lapps[c])
  225.       {
  226.         next=lapps[c]->windows;
  227.         while(next)
  228.         {
  229.             die=next;
  230.             next=next->w_ap_next;
  231.             kfree(die);
  232.         }
  233.         lapps[c]->windows=NULL;
  234.       }
  235. }
  236.